
// #include "tesk.hpp"
// #include "ring_queue.hpp"
// #include <ctime>
// #include <cstdlib>
// #include <unistd.h>

// // void *consumer_fun(void *args)
// // {
// //     while (true)
// //     {
// //         // sleep(1);
// //         RingQueue<int> *rq = static_cast<RingQueue<int> *>(args);
// //         int val;
// //         rq->pop(&val);
// //         std::cout << "                消费一个数据：" << val << std::endl;
// //     }
// //     return nullptr;
// // }
// // void *producers_fun(void *args)
// // {
// //     while (true)
// //     {

// //         RingQueue<int> *rq = static_cast<RingQueue<int> *>(args);
// //         int val = rand() % 10 + 1;
// //         rq->push(val);
// //         std::cout << "生产一个数据：" << val << std::endl;
// //         sleep(1);
// //     }

// //     return nullptr;
// // }
// // int main()
// // {
// //     srand((unsigned int)time(nullptr) & 12423);
// //     RingQueue<int> *rq = new RingQueue<int>();
// //     pthread_t c, p;
// //     pthread_create(&p, nullptr, producers_fun, rq);
// //     pthread_create(&c, nullptr, consumer_fun, rq);

// //     pthread_join(p,nullptr);
// //     pthread_join(c,nullptr);

// //     delete(rq);
// //     return 0;
// // }

// sem_t psem;
// sem_t csem;
// sem_t numsem;

// int countfun(int x, int y, char op)
// {
//     int ret = 0;
//     switch (op)
//     {
//     case '+':
//         ret = x + y;
//         break;
//     case '-':
//         ret = x - y;
//         break;
//     case '*':
//         ret = x * y;
//         break;
//     case '/':
//         if (y == 0)
//         {
//             std::cout << std::endl
//                       << "error";
//             return -1;
//         }
//         ret = x / y;
//         break;
//     case '%':
//         if (y == 0)
//         {
//             std::cout << std::endl
//                       << "error";

//             return -1;
//         }
//         ret = x % y;
//         break;
//     default:
//         std::cout << "error" << std::endl;
//         break;
//     }
//     return ret;
// }

// void *consumer_fun(void *args)
// {
//     while (true)
//     {
//         RingQueue<Count_Tesk> *rq = static_cast<RingQueue<Count_Tesk> *>(args);
//         Count_Tesk t;
//         sem_wait(&csem);
//         rq->pop(&t);
//         std::cout << t() << std::endl;
//         sem_post(&psem);
//     }
//     return nullptr;
// }
// void *producers_fun(void *args)
// {
//     while (true)
//     {
//         sem_wait(&numsem);
//         RingQueue<Count_Tesk> *rq = static_cast<RingQueue<Count_Tesk> *>(args);

//         int x = rand() % 10 + 1;
//         int y = rand() % 10;
//         char arr[5] = {'+', '-', '*', '/', '%'};
//         char op = arr[rand() % 5];
//         Count_Tesk t(x, y, op, countfun);
//         sem_wait(&psem);
//         rq->push(t);
//         std::cout << "生产一个数据：" << x << op << y << '='; //<< std::endl;
//         sem_post(&csem);
//     }

//     return nullptr;
// }

// int main()
// {
//     srand((unsigned int)time(nullptr) & 12423);
//     RingQueue<Count_Tesk> *rq = new RingQueue<Count_Tesk>();
//     pthread_t c, p;
//     pthread_create(&p, nullptr, producers_fun, rq);
//     pthread_create(&c, nullptr, consumer_fun, rq);
//     sem_init(&psem, 0, 1);
//     sem_init(&csem, 0, 0);
//     sem_init(&numsem, 0, 100000);
//     pthread_join(p, nullptr);
//     pthread_join(c, nullptr);

//     delete (rq);
//     return 0;
// }

// #include <iostream>
// #include <vector>
// #include <unistd.h>
// #include <stdlib.h>
// #include <semaphore.h>
// #include <pthread.h>
// #define NUM 16

// class RingQueue
// {

// private:
//     std::vector<int> q;//环形队列
//     int cap;//队列容量

//     sem_t data_sem;//代表数据个数信号量（初始为0）
//     sem_t space_sem;//代表空盘子的个数的信号量（初始为cap个）

//     int consume_step;//当前消费者访问的下标
//     int product_step;//当前生产者访问的下标

//     pthread_mutex_t consume_mutex;//让消费者互斥
//     pthread_mutex_t product_mutex;//让生产者互斥

// public:
//     RingQueue(int _cap = NUM) : q(_cap), cap(_cap)
//     {
//         //初始化信号量
//         sem_init(&data_sem, 0, 0);
//         sem_init(&space_sem, 0, cap);
//         consume_step = 0;
//         product_step = 0;
//         //初始化互斥量
//         pthread_mutex_init(&consume_mutex, nullptr);
//         pthread_mutex_init(&product_mutex, nullptr);
//     }
//     void PutData(const int &data)
//     {
//         sem_wait(&space_sem); // P
//         pthread_mutex_lock(&product_mutex);
//         q[consume_step] = data;
//         consume_step++;
//         consume_step %= cap;
//         pthread_mutex_unlock(&product_mutex);
//         sem_post(&data_sem); // V
//     }
//     void GetData(int &data)
//     {
//         sem_wait(&data_sem);
//         pthread_mutex_lock(&consume_mutex);
//         data = q[product_step];
//         product_step++;
//         product_step %= cap;
//         pthread_mutex_unlock(&consume_mutex);
//         sem_post(&space_sem);
//     }
//     ~RingQueue()
//     {
//         sem_destroy(&data_sem);
//         sem_destroy(&space_sem);
//         pthread_mutex_destroy(&product_mutex);
//         pthread_mutex_destroy(&consume_mutex);
//     }
// };
// void *consumer(void *arg)
// {
//     RingQueue *rqp = (RingQueue *)arg;
//     int data;
//     for (;;)
//     {
//         rqp->GetData(data);
//         std::cout << "Consume data done : " << data << std::endl;
//         sleep(1);
//     }
// }
// // more faster
// void *producter(void *arg)
// {
//     RingQueue *rqp = (RingQueue *)arg;

//     srand((unsigned long)time(NULL));
//     for (;;)
//     {
//         int data = rand() % 1024;
//         rqp->PutData(data);
//         std::cout << "Prodoct data done: " << data << std::endl;
//         // sleep(1);
//     }
// }

// int main()
// {
//     RingQueue rq;
//     pthread_t c1, c2, c3, c4, p1, p2, p3, p4;
//     pthread_create(&c1, NULL, consumer, (void *)&rq);
//     pthread_create(&c2, NULL, consumer, (void *)&rq);
//     pthread_create(&c3, NULL, consumer, (void *)&rq);
//     pthread_create(&c4, NULL, consumer, (void *)&rq);
//     pthread_create(&p1, NULL, producter, (void *)&rq);
//     pthread_create(&p2, NULL, producter, (void *)&rq);
//     pthread_create(&p3, NULL, producter, (void *)&rq);
//     pthread_create(&p4, NULL, producter, (void *)&rq);


//     pthread_join(c1, NULL);
//     pthread_join(c2, NULL);
//     pthread_join(c3, NULL);
//     pthread_join(c4, NULL);
//     pthread_join(p1, NULL);
//     pthread_join(p2, NULL);
//     pthread_join(p3, NULL);
//     pthread_join(p4, NULL);
//     return 0;
// }
